home *** CD-ROM | disk | FTP | other *** search
/ Java 1996 August / Java - Summer 1996.iso / kaffe-0.2 / config / i386-asm.h next >
Encoding:
C/C++ Source or Header  |  1996-02-13  |  15.5 KB  |  927 lines
  1. /*
  2.  * i386-asm.h
  3.  * Hand crafted inline voids to turn semi-understandable i386 instructions
  4.  * into machine code.
  5.  *
  6.  * Copyright (c) 1996 Systems Architecture Research Centre,
  7.  *           City University, London, UK.
  8.  *
  9.  * See the file "license.terms" for information on usage and redistribution
  10.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  11.  *
  12.  * Written by Tim Wilkinson <tim@sarc.city.ac.uk>, February 1996.
  13.  */
  14.  
  15. #include <assert.h>
  16. #include "gtypes.h"
  17.  
  18. extern nativecode* pc;
  19. #define    OUT    (*pc++)
  20.  
  21. #define    EXTERNAL_LINK(j)    addLink(j, (int)pc, 4+(int)pc, false)
  22. #define    INTERNAL_LINK(j)    addLink(j, (int)pc, 4+(int)pc, true)
  23.  
  24. inline void asm__adcl_RxR(int r1, int r2)
  25. {
  26.     OUT = 0x11;
  27.     OUT = 0xC0|(r1<<3)|r2;
  28. }
  29.  
  30. inline void asm__adcl_VxR(int v1, int r1)
  31. {
  32.     OUT = 0x81;
  33.     OUT = 0xD0|r1;
  34.     OUT = v1 & 0xff;
  35.     OUT = (v1 >> 8) & 0xff;
  36.     OUT = (v1 >> 16) & 0xff;
  37.     OUT = (v1 >> 24) & 0xff;
  38. }
  39.  
  40. inline void asm__addl_RxR(int r1, int r2)
  41. {
  42.     OUT = 0x01;
  43.     OUT = 0xC0|(r1<<3)|r2;
  44. }
  45.  
  46. inline void asm__addl_VxVoRo(int v1, int v2, int r1)
  47. {
  48.     /* addl v1,v2(r1) */
  49.     OUT = 0x81;
  50.     OUT = 0x85;
  51.     OUT = v2 & 0xff;
  52.     OUT = (v2 >> 8) & 0xff;
  53.     OUT = (v2 >> 16) & 0xff;
  54.     OUT = (v2 >> 24) & 0xff;
  55.     OUT = v1 & 0xff;
  56.     OUT = (v1 >> 8) & 0xff;
  57.     OUT = (v1 >> 16) & 0xff;
  58.     OUT = (v1 >> 24) & 0xff;
  59. }
  60.  
  61. inline void asm__addl_VxR(int v1, int r1)
  62. {
  63.     OUT = 0x81;
  64.     OUT = 0xC0|r1;
  65.     OUT = v1 & 0xff;
  66.     OUT = (v1 >> 8) & 0xff;
  67.     OUT = (v1 >> 16) & 0xff;
  68.     OUT = (v1 >> 24) & 0xff;
  69. }
  70.  
  71. inline void asm__andl_RxR(int r1, int r2)
  72. {
  73.     OUT = 0x21;
  74.     OUT = 0xC0|(r1<<3)|r2;
  75. }
  76.  
  77. inline void asm__andl_VxR(int v1, int r1)
  78. {
  79.     OUT = 0x81;
  80.     OUT = 0xE0|r1;
  81.     OUT = v1 & 0xff;
  82.     OUT = (v1 >> 8) & 0xff;
  83.     OUT = (v1 >> 16) & 0xff;
  84.     OUT = (v1 >> 24) & 0xff;
  85. }
  86.  
  87. inline void asm__brkpt(void)
  88. {
  89.     OUT = 0xCC;
  90. }
  91.  
  92. inline void asm__call_J(int j1)
  93. {
  94.     OUT = 0xE8;
  95.     INTERNAL_LINK(j1);
  96.     OUT = j1 & 0xff;
  97.     OUT = (j1 >> 8) & 0xff;
  98.     OUT = (j1 >> 16) & 0xff;
  99.     OUT = (j1 >> 24) & 0xff;
  100. }
  101.  
  102. inline void asm__call_X(int j1)
  103. {
  104.     OUT = 0xE8;
  105.     EXTERNAL_LINK(j1);
  106.     OUT = j1 & 0xff;
  107.     OUT = (j1 >> 8) & 0xff;
  108.     OUT = (j1 >> 16) & 0xff;
  109.     OUT = (j1 >> 24) & 0xff;
  110. }
  111.  
  112. inline void asm__call_sR(int r1)
  113. {
  114.     OUT = 0xFF;
  115.     OUT = 0xD0|r1;
  116. }
  117.  
  118. inline void asm__cmpl_RxR(int r1, int r2)
  119. {
  120.     OUT = 0x39;
  121.     OUT = 0xC0|(r1<<3)|r2;
  122. }
  123.  
  124. inline void asm__cmpl_VxR(int v1, int r1)
  125. {
  126.     OUT = 0x81;
  127.     OUT = 0xF8|r1;
  128.     OUT = v1 & 0xff;
  129.     OUT = (v1 >> 8) & 0xff;
  130.     OUT = (v1 >> 16) & 0xff;
  131.     OUT = (v1 >> 24) & 0xff;
  132. }
  133.  
  134. inline void asm__cmpl_VxVoRo (int v1, int v2, int r1)
  135. {
  136.     /* cmpl v1,v2(r1) */
  137.     OUT = 0x81;
  138.     OUT = 0xB8|r1;
  139.     if (r1 == REG_esp) {
  140.         OUT = 0x20|REG_esp;
  141.     }
  142.     OUT = v2 & 0xff;
  143.     OUT = (v2 >> 8) & 0xff;
  144.     OUT = (v2 >> 16) & 0xff;
  145.     OUT = (v2 >> 24) & 0xff;
  146.     OUT = v1 & 0xff;
  147.     OUT = (v1 >> 8) & 0xff;
  148.     OUT = (v1 >> 16) & 0xff;
  149.     OUT = (v1 >> 24) & 0xff;
  150. }
  151.  
  152. inline void asm__faddl_VoRo(int v1, int r1)
  153. {
  154.     /* faddl v1(r1) */
  155.     OUT = 0xDC;
  156.     OUT = 0x80|r1;
  157.     if (r1 == REG_esp) {
  158.         OUT = 0x20|REG_esp;
  159.     }
  160.     OUT = v1 & 0xff;
  161.     OUT = (v1 >> 8) & 0xff;
  162.     OUT = (v1 >> 16) & 0xff;
  163.     OUT = (v1 >> 24) & 0xff;
  164. }
  165.  
  166. inline void asm__fadds_VoRo(int v1, int r1)
  167. {
  168.     /* fadds v1(r1) */
  169.     OUT = 0xD8;
  170.     OUT = 0x80|r1;
  171.     if (r1 == REG_esp) {
  172.         OUT = 0x20|REG_esp;
  173.     }
  174.     OUT = v1 & 0xff;
  175.     OUT = (v1 >> 8) & 0xff;
  176.     OUT = (v1 >> 16) & 0xff;
  177.     OUT = (v1 >> 24) & 0xff;
  178. }
  179.  
  180. inline void asm__fdivl_VoRo(int v1, int r1)
  181. {
  182.     /* fdivl v1(r1) */
  183.     OUT = 0xDC;
  184.     OUT = 0xB0|r1;
  185.     if (r1 == REG_esp) {
  186.         OUT = 0x20|REG_esp;
  187.     }
  188.     OUT = v1 & 0xff;
  189.     OUT = (v1 >> 8) & 0xff;
  190.     OUT = (v1 >> 16) & 0xff;
  191.     OUT = (v1 >> 24) & 0xff;
  192. }
  193.  
  194. inline void asm__fdivs_VoRo(int v1, int r1)
  195. {
  196.     /* fdivs v1(r1) */
  197.     OUT = 0xD8;
  198.     OUT = 0xB0|r1;
  199.     if (r1 == REG_esp) {
  200.         OUT = 0x20|REG_esp;
  201.     }
  202.     OUT = v1 & 0xff;
  203.     OUT = (v1 >> 8) & 0xff;
  204.     OUT = (v1 >> 16) & 0xff;
  205.     OUT = (v1 >> 24) & 0xff;
  206. }
  207.  
  208. inline void asm__filds_VoRo(int v1, int r1)
  209. {
  210.     /* filds v1(r1) */
  211.     OUT = 0xDB;
  212.     OUT = 0x80|r1;
  213.     if (r1 == REG_esp) {
  214.         OUT = 0x20|REG_esp;
  215.     }
  216.     OUT = v1 & 0xff;
  217.     OUT = (v1 >> 8) & 0xff;
  218.     OUT = (v1 >> 16) & 0xff;
  219.     OUT = (v1 >> 24) & 0xff;
  220. }
  221.  
  222. inline void asm__fildd_VoRo(int v1, int r1)
  223. {
  224.     /* fildd v1(r1) */
  225.     OUT = 0xDF;
  226.     OUT = 0x80|r1;
  227.     if (r1 == REG_esp) {
  228.         OUT = 0x20|REG_esp;
  229.     }
  230.     OUT = v1 & 0xff;
  231.     OUT = (v1 >> 8) & 0xff;
  232.     OUT = (v1 >> 16) & 0xff;
  233.     OUT = (v1 >> 24) & 0xff;
  234. }
  235.  
  236. inline void asm__fistpl_VoRo(int v1, int r1)
  237. {
  238.     /* fistpl v1(r1) */
  239.     OUT = 0xDF;
  240.     OUT = 0xB8|r1;
  241.     if (r1 == REG_esp) {
  242.         OUT = 0x20|REG_esp;
  243.     }
  244.     OUT = v1 & 0xff;
  245.     OUT = (v1 >> 8) & 0xff;
  246.     OUT = (v1 >> 16) & 0xff;
  247.     OUT = (v1 >> 24) & 0xff;
  248. }
  249.  
  250. inline void asm__fistps_VoRo(int v1, int r1)
  251. {
  252.     /* fistps v1(r1) */
  253.     OUT = 0xDB;
  254.     OUT = 0x98|r1;
  255.     if (r1 == REG_esp) {
  256.         OUT = 0x20|REG_esp;
  257.     }
  258.     OUT = v1 & 0xff;
  259.     OUT = (v1 >> 8) & 0xff;
  260.     OUT = (v1 >> 16) & 0xff;
  261.     OUT = (v1 >> 24) & 0xff;
  262. }
  263.  
  264. inline void asm__fldl_VoRo(int v1, int r1)
  265. {
  266.     /* fldl v1(r1) */
  267.     OUT = 0xDD;
  268.     OUT = 0x80|r1;
  269.     if (r1 == REG_esp) {
  270.         OUT = 0x20|REG_esp;
  271.     }
  272.     OUT = v1 & 0xff;
  273.     OUT = (v1 >> 8) & 0xff;
  274.     OUT = (v1 >> 16) & 0xff;
  275.     OUT = (v1 >> 24) & 0xff;
  276. }
  277.  
  278. inline void asm__flds_VoRo(int v1, int r1)
  279. {
  280.     /* flds v1(r1) */
  281.     OUT = 0xD9;
  282.     OUT = 0x80|r1;
  283.     if (r1 == REG_esp) {
  284.         OUT = 0x20|REG_esp;
  285.     }
  286.     OUT = v1 & 0xff;
  287.     OUT = (v1 >> 8) & 0xff;
  288.     OUT = (v1 >> 16) & 0xff;
  289.     OUT = (v1 >> 24) & 0xff;
  290. }
  291.  
  292. inline void asm__fldz(void)
  293. {
  294.     OUT = 0xD9;
  295.     OUT = 0xEE;
  296. }
  297.  
  298. inline void asm__fmull_VoRo(int v1, int r1)
  299. {
  300.     /* fmull v1(r1) */
  301.     OUT = 0xDC;
  302.     OUT = 0x88|r1;
  303.     if (r1 == REG_esp) {
  304.         OUT = 0x20|REG_esp;
  305.     }
  306.     OUT = v1 & 0xff;
  307.     OUT = (v1 >> 8) & 0xff;
  308.     OUT = (v1 >> 16) & 0xff;
  309.     OUT = (v1 >> 24) & 0xff;
  310. }
  311.  
  312. inline void asm__fmuls_VoRo(int v1, int r1)
  313. {
  314.     /* fmuls v1(r1) */
  315.     OUT = 0xD8;
  316.     OUT = 0x88|r1;
  317.     if (r1 == REG_esp) {
  318.         OUT = 0x20|REG_esp;
  319.     }
  320.     OUT = v1 & 0xff;
  321.     OUT = (v1 >> 8) & 0xff;
  322.     OUT = (v1 >> 16) & 0xff;
  323.     OUT = (v1 >> 24) & 0xff;
  324. }
  325.  
  326. inline void asm__fstpl_VoRo(int v1, int r1)
  327. {
  328.     /* fstpl v1(r1) */
  329.     OUT = 0xDD;
  330.     OUT = 0x98|r1;
  331.     if (r1 == REG_esp) {
  332.         OUT = 0x20|REG_esp;
  333.     }
  334.     OUT = v1 & 0xff;
  335.     OUT = (v1 >> 8) & 0xff;
  336.     OUT = (v1 >> 16) & 0xff;
  337.     OUT = (v1 >> 24) & 0xff;
  338. }
  339.  
  340. inline void asm__fstps_VoRo(int v1, int r1)
  341. {
  342.     /* fstps v1(r1) */
  343.     OUT = 0xD9;
  344.     OUT = 0x98|r1;
  345.     if (r1 == REG_esp) {
  346.         OUT = 0x20|REG_esp;
  347.     }
  348.     OUT = v1 & 0xff;
  349.     OUT = (v1 >> 8) & 0xff;
  350.     OUT = (v1 >> 16) & 0xff;
  351.     OUT = (v1 >> 24) & 0xff;
  352. }
  353.  
  354. inline void asm__fsubl_VoRo(int v1, int r1)
  355. {
  356.     /* fsubl v1(r1) */
  357.     OUT = 0xDC;
  358.     OUT = 0xA0|r1;
  359.     if (r1 == REG_esp) {
  360.         OUT = 0x20|REG_esp;
  361.     }
  362.     OUT = v1 & 0xff;
  363.     OUT = (v1 >> 8) & 0xff;
  364.     OUT = (v1 >> 16) & 0xff;
  365.     OUT = (v1 >> 24) & 0xff;
  366. }
  367.  
  368. inline void asm__fsubs_VoRo(int v1, int r1)
  369. {
  370.     /* fsubs v1(r1) */
  371.     OUT = 0xD8;
  372.     OUT = 0xA0|r1;
  373.     if (r1 == REG_esp) {
  374.         OUT = 0x20|REG_esp;
  375.     }
  376.     OUT = v1 & 0xff;
  377.     OUT = (v1 >> 8) & 0xff;
  378.     OUT = (v1 >> 16) & 0xff;
  379.     OUT = (v1 >> 24) & 0xff;
  380. }
  381.  
  382. inline void asm__idivl_RxR(int r1, int r2)
  383. {
  384.     assert(r1 == REG_eax);
  385.     OUT = 0xF7;
  386.     OUT = 0xF8|r2;
  387. }
  388.  
  389. inline void asm__imull_RxR(int r1, int r2)
  390. {
  391.     OUT = 0x0F;
  392.     OUT = 0xAF;
  393.     OUT = 0xC0|(r2<<3)|r1;
  394. }
  395.  
  396. inline void asm__je_J(int j1)
  397. {
  398.     OUT = 0x0f;
  399.     OUT = 0x84;
  400.     INTERNAL_LINK(j1);
  401.     OUT = j1 & 0xff;
  402.     OUT = (j1 >> 8) & 0xff;
  403.     OUT = (j1 >> 16) & 0xff;
  404.     OUT = (j1 >> 24) & 0xff;
  405. }
  406.  
  407. inline void asm__jne_J(int j1)
  408. {
  409.     OUT = 0x0f;
  410.     OUT = 0x85;
  411.     INTERNAL_LINK(j1);
  412.     OUT = j1 & 0xff;
  413.     OUT = (j1 >> 8) & 0xff;
  414.     OUT = (j1 >> 16) & 0xff;
  415.     OUT = (j1 >> 24) & 0xff;
  416. }
  417.  
  418. inline void asm__jge_J(int j1)
  419. {
  420.     OUT = 0x0f;
  421.     OUT = 0x8d;
  422.     INTERNAL_LINK(j1);
  423.     OUT = j1 & 0xff;
  424.     OUT = (j1 >> 8) & 0xff;
  425.     OUT = (j1 >> 16) & 0xff;
  426.     OUT = (j1 >> 24) & 0xff;
  427. }
  428.  
  429. inline void asm__jgt_J(int j1)
  430. {
  431.     OUT = 0x0f;
  432.     OUT = 0x8f;
  433.     INTERNAL_LINK(j1);
  434.     OUT = j1 & 0xff;
  435.     OUT = (j1 >> 8) & 0xff;
  436.     OUT = (j1 >> 16) & 0xff;
  437.     OUT = (j1 >> 24) & 0xff;
  438. }
  439.  
  440. inline void asm__jle_J(int j1)
  441. {
  442.     OUT = 0x0f;
  443.     OUT = 0x8e;
  444.     INTERNAL_LINK(j1);
  445.     OUT = j1 & 0xff;
  446.     OUT = (j1 >> 8) & 0xff;
  447.     OUT = (j1 >> 16) & 0xff;
  448.     OUT = (j1 >> 24) & 0xff;
  449. }
  450.  
  451. inline void asm__jlt_J(int j1)
  452. {
  453.     OUT = 0x0f;
  454.     OUT = 0x8c;
  455.     INTERNAL_LINK(j1);
  456.     OUT = j1 & 0xff;
  457.     OUT = (j1 >> 8) & 0xff;
  458.     OUT = (j1 >> 16) & 0xff;
  459.     OUT = (j1 >> 24) & 0xff;
  460. }
  461.  
  462. inline void asm__jmpl_J(int j1)
  463. {
  464.     OUT = 0xE9;
  465.     INTERNAL_LINK(j1);
  466.     OUT = j1 & 0xff;
  467.     OUT = (j1 >> 8) & 0xff;
  468.     OUT = (j1 >> 16) & 0xff;
  469.     OUT = (j1 >> 24) & 0xff;
  470. }
  471.  
  472. inline void asm__jmpl_sR(int r1)
  473. {
  474.     OUT = 0xFF;
  475.     OUT = 0xE0|r1;
  476. }
  477.  
  478. inline void asm__leal_VoRxRxVoxR(int v1, int r1, int r2, int v2, int r3)
  479. {
  480.     /* leal v1(r1,r2,v2),r3 */
  481.     assert(v2 == 1 || v2 == 4 || v2 == 8);
  482.     assert(r2 != REG_esp);
  483.     OUT = 0x8D;
  484.     OUT = 0x84|(r3<<3);
  485.     if (v2 == 1) {
  486.         OUT = 0x00|(r2<<3)|r1;
  487.     }
  488.     else if (v2 == 4) {
  489.         OUT = 0x80|(r2<<3)|r1;
  490.     }
  491.     else {
  492.         OUT = 0xC0|(r2<<3)|r1;
  493.     }
  494.     OUT = v1 & 0xff;
  495.     OUT = (v1 >> 8) & 0xff;
  496.     OUT = (v1 >> 16) & 0xff;
  497.     OUT = (v1 >> 24) & 0xff;
  498. }
  499.  
  500. inline void asm__movb_RxVoRxRxVo(int r1, int v1, int r2, int r3, int v2)
  501. {
  502.     /* movb r1,v1(r2,r3,v2) */
  503.     assert(v2 == 1 || v2 == 2 || v2 == 4 || v2 == 8);
  504.     assert(r3 != REG_esp);
  505.     OUT = 0x88;
  506.     OUT = 0x84|(r1<<3);
  507.     if (v2 == 1) {
  508.         OUT = 0x00|(r3<<3)|r2;
  509.     }
  510.     else if (v2 == 2) {
  511.         OUT = 0x40|(r3<<3)|r2;
  512.     }
  513.     else if (v2 == 4) {
  514.         OUT = 0x80|(r3<<3)|r2;
  515.     }
  516.     else {
  517.         OUT = 0xC0|(r3<<3)|r2;
  518.     }
  519.     OUT = v1 & 0xff;
  520.     OUT = (v1 >> 8) & 0xff;
  521.     OUT = (v1 >> 16) & 0xff;
  522.     OUT = (v1 >> 24) & 0xff;
  523. }
  524.  
  525. inline void asm__movw_RxVoRxRxVo(int r1, int v1, int r2, int r3, int v2)
  526. {
  527.     /* movw r1,v1(r2,r3,v2) */
  528.     assert(v2 == 1 || v2 == 2 || v2 == 4 || v2 == 8);
  529.     assert(r3 != REG_esp);
  530.     OUT = 0x66;
  531.     OUT = 0x89;
  532.     OUT = 0x84|(r1<<3);
  533.     if (v2 == 1) {
  534.         OUT = 0x00|(r3<<3)|r2;
  535.     }
  536.     else if (v2 == 2) {
  537.         OUT = 0x40|(r3<<3)|r2;
  538.     }
  539.     else if (v2 == 4) {
  540.         OUT = 0x80|(r3<<3)|r2;
  541.     }
  542.     else {
  543.         OUT = 0xC0|(r3<<3)|r2;
  544.     }
  545.     OUT = v1 & 0xff;
  546.     OUT = (v1 >> 8) & 0xff;
  547.     OUT = (v1 >> 16) & 0xff;
  548.     OUT = (v1 >> 24) & 0xff;
  549. }
  550.  
  551. inline void asm__movl_oRoxR(int r1, int r2)
  552. {
  553.     /* movl (r1),r2 */
  554.     OUT = 0x8B;
  555.     OUT = 0x00|(r2<<3)|r1;
  556.     if (r1 == REG_esp) {
  557.         OUT = 0x20|REG_esp;
  558.     }
  559. }
  560.  
  561. inline void asm__movl_VoRoxR(int v1, int r1, int r2)
  562. {
  563.     /* movl v1(r1),r2 */
  564.     OUT = 0x8B;
  565.     OUT = 0x80|(r2<<3)|r1;
  566.     if (r1 == REG_esp) {
  567.         OUT = 0x20|REG_esp;
  568.     }
  569.     OUT = v1 & 0xff;
  570.     OUT = (v1 >> 8) & 0xff;
  571.     OUT = (v1 >> 16) & 0xff;
  572.     OUT = (v1 >> 24) & 0xff;
  573. }
  574.  
  575. inline void asm__movl_VoRxRxVoxR(int v1, int r1, int r2, int v2, int r3)
  576. {
  577.     /* movl v1(r1,r2,v2),r3 */
  578.     assert(v2 == 1 || v2 == 4 || v2 == 8);
  579.     assert(r2 != REG_esp);
  580.     OUT = 0x8B;
  581.     OUT = 0x84|(r3<<3);
  582.     if (v2 == 1) {
  583.         OUT = 0x00|(r2<<3)|r1;
  584.     }
  585.     else if (v2 == 4) {
  586.         OUT = 0x80|(r2<<3)|r1;
  587.     }
  588.     else {
  589.         OUT = 0xC0|(r2<<3)|r1;
  590.     }
  591.     OUT = v1 & 0xff;
  592.     OUT = (v1 >> 8) & 0xff;
  593.     OUT = (v1 >> 16) & 0xff;
  594.     OUT = (v1 >> 24) & 0xff;
  595. }
  596.  
  597. inline void asm__movl_RxVoRo(int r1, int v1, int r2)
  598. {
  599.     /* movl r1,v1(r2) */
  600.     OUT = 0x89;
  601.     OUT = 0x80|(r1<<3)|r2;
  602.     if (r2 == REG_esp) {
  603.         OUT = 0x20|REG_esp;
  604.     }
  605.     OUT = v1 & 0xff;
  606.     OUT = (v1 >> 8) & 0xff;
  607.     OUT = (v1 >> 16) & 0xff;
  608.     OUT = (v1 >> 24) & 0xff;
  609. }
  610.  
  611. inline void asm__movl_RxVoRxRxVo(int r1, int v1, int r2, int r3, int v2)
  612. {
  613.     /* movl r1,v1(r2,r3,v2) */
  614.     assert(v2 == 1 || v2 == 4 || v2 == 8);
  615.     assert(r3 != REG_esp);
  616.     OUT = 0x89;
  617.     OUT = 0x84|(r1<<3);
  618.     if (v2 == 1) {
  619.         OUT = 0x00|(r3<<3)|r2;
  620.     }
  621.     else if (v2 == 4) {
  622.         OUT = 0x80|(r3<<3)|r2;
  623.     }
  624.     else {
  625.         OUT = 0xC0|(r3<<3)|r2;
  626.     }
  627.     OUT = v1 & 0xff;
  628.     OUT = (v1 >> 8) & 0xff;
  629.     OUT = (v1 >> 16) & 0xff;
  630.     OUT = (v1 >> 24) & 0xff;
  631. }
  632.  
  633. inline void asm__movl_RxoVo(int r1, int v1)
  634. {
  635.     OUT = 0x89;
  636.     OUT = 0x05|(r1<<3);
  637.     OUT = v1 & 0xff;
  638.     OUT = (v1 >> 8) & 0xff;
  639.     OUT = (v1 >> 16) & 0xff;
  640.     OUT = (v1 >> 24) & 0xff;
  641. }
  642.  
  643. inline void asm__movl_oVoxR(int v1, int r1)
  644. {
  645.     OUT = 0x8B;
  646.     OUT = 0x05|(r1<<3);
  647.     OUT = v1 & 0xff;
  648.     OUT = (v1 >> 8) & 0xff;
  649.     OUT = (v1 >> 16) & 0xff;
  650.     OUT = (v1 >> 24) & 0xff;
  651. }
  652.  
  653. inline void asm__movl_RxR(int r1, int r2)
  654. {
  655.     OUT = 0x89;
  656.     OUT = 0xC0|(r1<<3)|r2;
  657. }
  658.  
  659. inline void asm__movl_VxR(int v1, int r1)
  660. {
  661.     OUT = 0xB8|r1;
  662.     OUT = v1 & 0xff;
  663.     OUT = (v1 >> 8) & 0xff;
  664.     OUT = (v1 >> 16) & 0xff;
  665.     OUT = (v1 >> 24) & 0xff;
  666. }
  667.  
  668. inline void asm__movsbl_VoRxRxVoxR(int v1, int r1, int r2, int v2, int r3)
  669. {
  670.     /* movsbl v1(r1,r2,v2),r3 */
  671.     assert(v2 == 1 || v2 == 4 || v2 == 8);
  672.     assert(r3 != REG_esp);
  673.     OUT = 0x0F;
  674.     OUT = 0xBE;
  675.     OUT = 0x84|(r1<<3);
  676.     if (v2 == 1) {
  677.         OUT = 0x00|(r3<<3)|r2;
  678.     }
  679.     else if (v2 == 4) {
  680.         OUT = 0x80|(r3<<3)|r2;
  681.     }
  682.     else {
  683.         OUT = 0xC0|(r3<<3)|r2;
  684.     }
  685.     OUT = v1 & 0xff;
  686.     OUT = (v1 >> 8) & 0xff;
  687.     OUT = (v1 >> 16) & 0xff;
  688.     OUT = (v1 >> 24) & 0xff;
  689. }
  690.  
  691. inline void asm__movsbl_RxR(int r1, int r2)
  692. {
  693.     /* movsbl r1,r2 */
  694.     OUT = 0x0F;
  695.     OUT = 0xBE;
  696.     OUT = 0xC0|(r2<<3)|r1;
  697. }
  698.  
  699. inline void asm__movswl_VoRxRxVoxR(int v1, int r1, int r2, int v2, int r3)
  700. {
  701.     /* movswl v1(r1,r2,v2),r3 */
  702.     assert(v2 == 1 || v2 == 4 || v2 == 8);
  703.     assert(r2 != REG_esp);
  704.     OUT = 0x0F;
  705.     OUT = 0xBF;
  706.     OUT = 0x84|(r3<<3);
  707.     if (v2 == 1) {
  708.         OUT = 0x00|(r2<<3)|r1;
  709.     }
  710.     else if (v2 == 4) {
  711.         OUT = 0x80|(r2<<3)|r1;
  712.     }
  713.     else {
  714.         OUT = 0xC0|(r2<<3)|r1;
  715.     }
  716.     OUT = v1 & 0xff;
  717.     OUT = (v1 >> 8) & 0xff;
  718.     OUT = (v1 >> 16) & 0xff;
  719.     OUT = (v1 >> 24) & 0xff;
  720. }
  721.  
  722. inline void asm__movswl_RxR(int r1, int r2)
  723. {
  724.     OUT = 0x0F;
  725.     OUT = 0xBF;
  726.     OUT = 0xC0|(r2<<3)|r1;
  727. }
  728.  
  729. inline void asm__movzbl_VoRxRxVoxR(int v1, int r1, int r2, int v2, int r3)
  730. {
  731.     /* movzbl v1(r1,r2,v2),r3 */
  732.     assert(v2 == 1 || v2 == 4 || v2 == 8);
  733.     assert(r2 != REG_esp);
  734.     OUT = 0x0F;
  735.     OUT = 0xB6;
  736.     OUT = 0x84|(r3<<3);
  737.     if (v2 == 1) {
  738.         OUT = 0x00|(r2<<3)|r1;
  739.     }
  740.     else if (v2 == 4) {
  741.         OUT = 0x80|(r2<<3)|r1;
  742.     }
  743.     else {
  744.         OUT = 0xC0|(r2<<3)|r1;
  745.     }
  746.     OUT = v1 & 0xff;
  747.     OUT = (v1 >> 8) & 0xff;
  748.     OUT = (v1 >> 16) & 0xff;
  749.     OUT = (v1 >> 24) & 0xff;
  750. }
  751.  
  752. inline void asm__movzwl_RxR(int r1, int r2)
  753. {
  754.     OUT = 0x0F;
  755.     OUT = 0xB7;
  756.     OUT = 0xC0|(r2<<3)|r1;
  757. }
  758.  
  759. inline void asm__negl_R(int r1)
  760. {
  761.     OUT = 0xF7;
  762.     OUT = 0xD0|r1;
  763. }
  764.  
  765. inline void asm__orl_RxR(int r1, int r2)
  766. {
  767.     OUT = 0x09;
  768.     OUT = 0xC0|(r1<<3)|r2;
  769. }
  770.  
  771. inline void asm__popl_R(int r1)
  772. {
  773.     OUT = 0x58|r1;
  774. }
  775.  
  776. inline void asm__pushl_R(int r1)
  777. {
  778.     OUT = 0x50|r1;
  779. }
  780.  
  781. inline void asm__pushl_VoRo(int v1, int r1)
  782. {
  783.     OUT = 0xFF;
  784.     OUT = 0xB0|r1;
  785.     if (r1 == REG_esp) {
  786.         OUT = 0x20|REG_esp;
  787.     }
  788.     OUT = v1 & 0xff;
  789.     OUT = (v1 >> 8) & 0xff;
  790.     OUT = (v1 >> 16) & 0xff;
  791.     OUT = (v1 >> 24) & 0xff;
  792. }
  793.  
  794. inline void asm__pushl_V(int v1)
  795. {
  796.     OUT = 0x68;
  797.     OUT = v1 & 0xff;
  798.     OUT = (v1 >> 8) & 0xff;
  799.     OUT = (v1 >> 16) & 0xff;
  800.     OUT = (v1 >> 24) & 0xff;
  801. }
  802.  
  803. inline void asm__ret(void)
  804. {
  805.     OUT = 0xC3;
  806. }
  807.  
  808. inline void asm__sall_RxVoRo(int r1, int v1, int r2)
  809. {
  810.     /* sall r1,v1(r2) */
  811.     assert(r1 == REG_ecx);
  812.     OUT = 0xD3;
  813.     OUT = 0xA0|r2;
  814.     if (r2 == REG_esp) {
  815.         OUT = 0x20|REG_esp;
  816.     }
  817.     OUT = v1 & 0xff;
  818.     OUT = (v1 >> 8) & 0xff;
  819.     OUT = (v1 >> 16) & 0xff;
  820.     OUT = (v1 >> 24) & 0xff;
  821. }
  822.  
  823. inline void asm__sarl_RxVoRo(int r1, int v1, int r2)
  824. {
  825.     /* sarl r1,v1(r2) */
  826.     assert(r1 == REG_ecx);
  827.     OUT = 0xD3;
  828.     OUT = 0xB8|r2;
  829.     if (r2 == REG_esp) {
  830.         OUT = 0x20|REG_esp;
  831.     }
  832.     OUT = v1 & 0xff;
  833.     OUT = (v1 >> 8) & 0xff;
  834.     OUT = (v1 >> 16) & 0xff;
  835.     OUT = (v1 >> 24) & 0xff;
  836. }
  837.  
  838. inline void asm__sarl_VxR(int v1, int r1)
  839. {
  840.     assert(v1 >= 0 && v1 <= 255);
  841.     OUT = 0xC1;
  842.     OUT = 0xF8|r1;
  843.     OUT = v1;
  844. }
  845.  
  846. inline void asm__sbbl_RxR(int r1, int r2)
  847. {
  848.     OUT = 0x19;
  849.     OUT = 0xC0|(r1<<3)|r2;
  850. }
  851.  
  852. inline void asm__shrl_RxVoRo(int r1, int v1, int r2)
  853. {
  854.     /* shrl r1,v1(r2) */
  855.     assert(r1 == REG_ecx);
  856.     OUT = 0xD3;
  857.     OUT = 0xA8|r2;
  858.     if (r2 == REG_esp) {
  859.         OUT = 0x20|REG_esp;
  860.     }
  861.     OUT = v1 & 0xff;
  862.     OUT = (v1 >> 8) & 0xff;
  863.     OUT = (v1 >> 16) & 0xff;
  864.     OUT = (v1 >> 24) & 0xff;
  865. }
  866.  
  867. inline void asm__subl_RxR(int r1, int r2)
  868. {
  869.     OUT = 0x29;
  870.     OUT = 0xC0|(r1<<3)|r2;
  871. }
  872.  
  873. inline void asm__subl_VxR(int v1, int r1)
  874. {
  875.     OUT = 0x81;
  876.     OUT = 0xE8|r1;
  877.     OUT = v1 & 0xff;
  878.     OUT = (v1 >> 8) & 0xff;
  879.     OUT = (v1 >> 16) & 0xff;
  880.     OUT = (v1 >> 24) & 0xff;
  881. }
  882.  
  883. inline void asm__xchgl_RxR(int r1, int r2)
  884. {
  885.     OUT = 0x87;
  886.     OUT = 0xC0|(r1<<3)|r2;
  887. }
  888.  
  889. inline void asm__xorl_RxR(int r1, int r2)
  890. {
  891.     OUT = 0x31;
  892.     OUT = 0xC0|(r1<<3)|r2;
  893. }
  894.  
  895. /*
  896.  * Magic instruction used in INVOKE....
  897.  */
  898. inline void asm__skipeq5(void)
  899. {
  900.     OUT = 0x74;
  901.     OUT = 18;
  902. }
  903.  
  904. /*
  905.  * Magic instruction used in TABLESWITCH
  906.  */
  907. inline void asm__skipb1(void)
  908. {
  909.     OUT = 0x72;
  910.     OUT = 5;
  911. }
  912.  
  913. /*
  914.  * Magic instructions used in LOOKUPSWITCH
  915.  */
  916. inline void asm__skipeq3(void)
  917. {
  918.     OUT = 0x74;
  919.     OUT = 10;
  920. }
  921.  
  922. inline void asm__skipneback5(void)
  923. {
  924.     OUT = 0x75;
  925.     OUT = -16;
  926. }
  927.